This is to check whether a given type for
a list may have nullable entries.

First of all, this gets rid of `readOperation`, because
it's almost identical to `query`, which should save us
some bytes.

`readSelection` has been reimplemented. Instead of writing
fields onto data directly, it now first stores them in
`dataFieldValue`.

At any point when we encounter an uncached field that
is NOT nullable, we return undefined.
This is done by checking `dataFieldValue` against
the schema. This is now done in one place to save
some space and the hassle of reading repetitive code.

This works because we now represent uncached values
as `undefined`, which has been done in the past,
but has been removed. Hence:

- When `dataFieldValue` is `undefined` and a field
  is nullable then we write `null` and continue
- When `dataFieldValue` is `undefined` and a field
  is NOT nullable then we return `undefined` instead
  of `data` immediately
- Otherwise we write the field as usual

This is nice, because that means `undefined` cascades
upwards and this same logic also applies to resolved
links!

When no field has been set on Query and the result
would've been partially complete, then return
`undefined` for the entire Query.

…eturned

If we encounter an uncached, nullable field we'd set
ctx.partial, but if we then later return early with
undefined, that'd still be set!

Instead we need to set it after iterating, so that
early `return undefined` statements skip setting
ctx.partial